home *** CD-ROM | disk | FTP | other *** search
/ MacTech 1 to 12 / MacTech-vol-1-12.toast / Source / MacTech® Magazine / Volume 04 - 1988 / 04.11 Nov 88 / fast rotate source / rotate.a changes < prev    next >
Encoding:
Text File  |  1988-05-18  |  6.0 KB  |  238 lines  |  [TEXT/MPS ]
  1. ; Following is the changed portion of ROTATE.A:
  2.     lea    localVars,a0
  3.  
  4.     ; Synchronize with the TickCount rollover.
  5.     move.l    ticks, d0            ; get the time
  6. @1    cmp.l    ticks, d0            ; changed yet?
  7.     beq.s    @1                    ; nope: loop
  8.  
  9.     ; Strobe the starting time.
  10.     move.l    ticks, startTime-localVars(a0) ; save starting time, in ticks
  11.  
  12. ;
  13. ; initialize d0 to contain the pointer to the srcMap
  14. ;
  15.     move.w    rowbytes(a1),d0        ; get rowbytes of srcMap
  16.     
  17. ;
  18. ; get regs pointing to bits
  19. ;
  20.     move.l    (a1),a1                ; a1 pts to BITS of src bitMap    
  21.     move.l    (a2),a3                ; a3 pts to BITS of dest bitMap
  22.  
  23. ; 
  24. ; compute the lower left corner of the destMap - this maps to the upper left
  25. ; corner of the srcMap and will be used as base from which to offset into
  26. ; the dest map when we need to set a bit
  27. ;
  28.     clr.l    d1                    ; clear d1 
  29.     move.w    d0,d1                ; load rowBytes of srcMap
  30.                                 ; (rowBytes of srcMap = ht of destMap)
  31.     lsl.w    #3,d1                ; multiply by 8 to get ht of destMap when rot'd
  32.     mulu.w    d7,d1                ; multiply by rowbytes(destMap) = #words in
  33.     sub.w    d7,d1                ; destMap less one row
  34.     add.l    a3,d1                ; add the computed offset to the baseAddr of destMap
  35.     move.l    d1,lowerLeft-localVars(a0)    ; init lowerLeft
  36. ;
  37. ;-------------------------------------------------------------------------------
  38. ;    a0 = baseAddr for our locals        |    d0 = rowbytes of srcMap
  39. ;    a1 = points to bits of src bitMap    |    d1 = SCRATCH
  40. ;    a2 = SCRATCH                        |    d2 = colmCounter
  41. ;    a3 = dest bits                        |    d3 = current srcMap word 
  42. ;    a4 = SCRATCH                        |    d4 = colmBitLoop counter
  43. ;    a5 = not used                        |    d5 = current word destMap
  44. ;    a6 = not used                        |    d6 = insideLoop count (current bit)
  45. ;    a7 = not used                        |    d7 = rowBytes of dest bitMap
  46. ;-------------------------------------------------------------------------------
  47. ;
  48.  
  49. ;    _Debugger;
  50.     
  51. ; init wordCount to zero 
  52. ;
  53.     move.w    #0,wordCount-localVars(a0)    ; set wordCount to one before we start
  54. ;
  55. ; init colmLoop counter
  56. ;
  57.     move.w    d7,d2                ; get rowBytes(dest)
  58.     lsr        #1,d2                ; divide by 2 - d2 now contains the outer counter
  59.     move.w    d2,colmCount-localVars(a0)    ; put the max value away for reference
  60.     moveq.l    #0,d2                ; set d2 to zero since we use it for the counter
  61.  
  62. colmLoop
  63. ;
  64. ; this is the outside loop
  65. ;
  66.     move.w    #15,d4                ; init colmBitLoop counter to 15
  67.     move.l    lowerLeft-localVars(a0), a2    ; init currentWord    
  68.  
  69. colmBitLoop
  70. ;
  71. ; this is the loop that does the bit counting in the destMap - it is really a
  72. ; misuse of the 'dbra' instruction since it is not an independent loop but it
  73. ; is a quite cheap method of doing our counting
  74. ;
  75.  
  76.     cmp.w    #7, d4                        ; are we doing high byte or low?
  77.     bgt        dobyte1                        ; skip if high byte
  78.     addq    #1, a2                        ; else point to low byte
  79. dobyte1
  80.  
  81. rowLoop
  82. ;
  83. ; loop across each row in the srcMap and keep count each time we do a row
  84. ; this 'rowCount' will used to compute the offset from 'lowerLeft'
  85. ;
  86.     move.w    (a1)+, d3                    ; get a word to rotate into d3
  87.     addq.w    #2,wordCount-localVars(a0)    ; add 1 for each word •••jdo•••
  88.     
  89.     add.w    d3, d3                        ; test next bit in the current source word
  90.     bcc.s    NoBitToChange                ; if bit’s not set, skip to next
  91.     bset    d4, (a2)                    ; set proper bit in high or low byte in currentWord
  92. noBitToChange
  93.     sub.l    d7, a2                        ; subtract rowBytes(destMap) from current word
  94.  
  95.     ; Do the same as above, fifteen more times.
  96.     add.w    d3, d3
  97.     bcc.s    @1
  98.     bset    d4, (a2)
  99. @1    sub.l    d7, a2
  100.  
  101.     add.w    d3, d3
  102.     bcc.s    @2
  103.     bset    d4, (a2)
  104. @2    sub.l    d7, a2
  105.  
  106.     add.w    d3, d3
  107.     bcc.s    @3
  108.     bset    d4, (a2)
  109. @3    sub.l    d7, a2
  110.  
  111.     add.w    d3, d3
  112.     bcc.s    @4
  113.     bset    d4, (a2)
  114. @4    sub.l    d7, a2
  115.  
  116.     add.w    d3, d3
  117.     bcc.s    @5
  118.     bset    d4, (a2)
  119. @5    sub.l    d7, a2
  120.  
  121.     add.w    d3, d3
  122.     bcc.s    @6
  123.     bset    d4, (a2)
  124. @6    sub.l    d7, a2
  125.  
  126.     add.w    d3, d3
  127.     bcc.s    @7
  128.     bset    d4, (a2)
  129. @7    sub.l    d7, a2
  130.  
  131.     add.w    d3, d3
  132.     bcc.s    @8
  133.     bset    d4, (a2)
  134. @8    sub.l    d7, a2
  135.  
  136.     add.w    d3, d3
  137.     bcc.s    @9
  138.     bset    d4, (a2)
  139. @9    sub.l    d7, a2
  140.  
  141.     add.w    d3, d3
  142.     bcc.s    @10
  143.     bset    d4, (a2)
  144. @10    sub.l    d7, a2
  145.  
  146.     add.w    d3, d3
  147.     bcc.s    @11
  148.     bset    d4, (a2)
  149. @11    sub.l    d7, a2
  150.  
  151.     add.w    d3, d3
  152.     bcc.s    @12
  153.     bset    d4, (a2)
  154. @12    sub.l    d7, a2
  155.  
  156.     add.w    d3, d3
  157.     bcc.s    @13
  158.     bset    d4, (a2)
  159. @13    sub.l    d7, a2
  160.  
  161.     add.w    d3, d3
  162.     bcc.s    @14
  163.     bset    d4, (a2)
  164. @14    sub.l    d7, a2
  165.  
  166.     add.w    d3, d3
  167.     bcc.s    @15
  168.     bset    d4, (a2)
  169. @15    sub.l    d7, a2
  170.  
  171. ;
  172. ; at this point we've just completed a word from the srcMap
  173. ;
  174.     cmp        wordCount-localVars(a0),d0        ; cmp wordCount to rowBytes-are we done with a row ?
  175.     bne        rowLoop                            ; no - do another word
  176.     
  177.     cmp.w    #7, d4                        ; did we do high byte or low?
  178.     bgt        dobyte2                        ; skip if high byte
  179.     subq    #1, a2                        ; else undo the fudge to a2
  180. dobyte2
  181.  
  182. ;
  183. ; we just completed a row so add 2 to the count
  184. ;
  185.     move.w    #0,wordCount-localVars(a0)        ; •••jdo••• reset wordCount to zero
  186.  
  187. ;    
  188. ; the following use of dbra keeps track of our destMap bit for us
  189. ;
  190.     move.l    lowerLeft-localVars(a0), a2    ; re-init currentWord    
  191.                                         ; set the currentWord to the lowerLeft(current)
  192.                                         ; lowerLeft is moved over (right) by a word each
  193.                                         ; time we do a row in the srcMap
  194.     dbra    d4,colmBitLoop                ; go thru the bits (15->0) in the
  195.                                         ; destMap - then exit and do it
  196.                                         ; again for rowBytes/2 times
  197.  
  198. ;
  199. ; were done counting thru the bits of a destMap word - at this point we have
  200. ; actually finished a column in the destMap. The column is a multiple of
  201. ; 16 bits wide (and being at least 1 colm) and as tall as the destMap is
  202. ; (which is also equal to rowBytes of the srcMap)
  203. ;
  204.     addq.l    #2,lowerLeft-localVars(a0)        ; this moves us into the next
  205.                                             ; 'column' of bits in the destMap
  206.     addq.w    #1,d2                            ; add 1 to the colmLoop counter
  207.     cmp        colmCount-localVars(a0),d2        ; are we done yet ?
  208.     bne        colmLoop                        ; no - do it again
  209.                                             ; else we're done
  210. ;
  211. ; were done so lets do our clean-up/restore and go away gracefully
  212. ;
  213.     move.l    ticks, d0            ; get the current time…
  214.     sub.l    startTime-localVars(a0), d0 ; …less starting time
  215.     _Debugger                    ; and let me see the time it took
  216.  
  217.     movem.l    (sp)+,d3-d7/a2-a5    ; restore registers
  218.     unlk    a6                    ; clean up stack frame
  219.     move.l    (sp)+,a0            ; return address
  220.     add.l    #8,sp                ; pop parameters off stack
  221.     jmp        (a0)                 ; bye y'all!
  222.     
  223. ;
  224. ; set up our data storage area
  225. ;
  226. localVars                        ; the beginning of our local var storage area
  227. colmCount        ds.w    1
  228. currentWord        ds.l    1
  229. lowerLeft        ds.l    1
  230. wordCount        ds.w    1
  231. startTime        ds.l    1
  232.  
  233.     ENDP
  234.     
  235.     END
  236.     
  237.  
  238.